In a data processing and management system having a distributed processor configuration, data requested by a user is acquired from memory by establishing a pipeline between a process managing the memory and a receiving process. (Typically, a receiving process may be one of a number of so-called I/O processes designed, for example, to display data on a display or to output data to a printer.)
A pipeline to acquire data is typically established using a series of commands executed by a central control program (taskmaster). The commands are executed in the order that they are contained in the series. The execution of a command means that the taskmaster invokes a program (process) identified by the command. The program then performs its intended function, such as, for example, retrieving the data from memory or decompressing (expanding) the unloaded data. When a program completes its intended function, it then notifies the taskmaster of that fact in a conventional manner, e.g., by generating a so-called interrupt. The taskmaster then interrogates a status word associated with the program to determine whether the program successfully executed its intended function. If the status word indicates that is the case, then the taskmaster executes the next command in the series. Otherwise, the taskmaster executes a so-called error handling (diagnostic) program to hopefully determine the reason for the failure.
It can be appreciated that using a taskmaster (control program) to invoke and oversee the operation of each command in a series of commands is inefficient from the standpoint that it consumes real time. In addition, in the event that the demands on the taskmaster increase, then the taskmaster could become overloaded, thereby slowing down the establishment of the pipeline.
Moreover, in the event that the desired data is stored in memory as large blocks (fragments) of data, as would be the case where the data represents, for example, one or more high resolution images, then the taskmaster would have to repeat the execution of the series of commands to obtain each such fragment. Alternatively, the series of command could be constructed such that certain commands are repeated and, therefore, are executed more than once. It can be appreciated, however, that if the data comprises an appreciable number of fragments, then the series would contain a similar number of commands, thereby making the execution of the series unwieldy.
One way to handle this problem is to design a user interface process that would perform each function that is performed by the series of commands. In this sense, then, only one process would be invoked to establish the pipeline and obtain the data for display. However, such an interface process would be complex and large. A program that is complex and large is extremely difficult to modify to incorporate new features. Moreover, once such a program has been so modified it is extremely difficult to debug.